JavaScript Iterator Helpers: שליטה בעיבוד זרמים פונקציונלי

            IteratorHelpers.map(iterable, mapperFn)
AsyncIteratorHelpers.map(asyncIterable, mapperFn)

            

              
                Copy
              
            
          

            function* countUpTo(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

const numbers = countUpTo(5);
const doubledNumbersIterator = IteratorHelpers.map(numbers, x => x * 2);

console.log([...doubledNumbersIterator]); // Output: [2, 4, 6, 8, 10]

            

              
                Copy
              
            
          

            IteratorHelpers.filter(iterable, predicateFn)
AsyncIteratorHelpers.filter(asyncIterable, predicateFn)

            

              
                Copy
              
            
          

            function* generateSequence(limit) {
  for (let i = 0; i < limit; i++) {
    yield i;
  }
}

const sequence = generateSequence(10);
const evenNumbersIterator = IteratorHelpers.filter(sequence, x => x % 2 === 0);

console.log([...evenNumbersIterator]); // Output: [0, 2, 4, 6, 8]

            

              
                Copy
              
            
          

            IteratorHelpers.take(iterable, count)
AsyncIteratorHelpers.take(asyncIterable, count)

            

              
                Copy
              
            
          

            function* infiniteCounter() {
  let i = 0;
  while (true) {
    yield i++;
  }
}

const firstFive = IteratorHelpers.take(infiniteCounter(), 5);

console.log([...firstFive]); // Output: [0, 1, 2, 3, 4]

            

              
                Copy
              
            
          

            IteratorHelpers.drop(iterable, count)
AsyncIteratorHelpers.drop(asyncIterable, count)

            

              
                Copy
              
            
          

            function* dataStream() {
  yield 'a';
  yield 'b';
  yield 'c';
  yield 'd';
  yield 'e';
}

const remaining = IteratorHelpers.drop(dataStream(), 3);

console.log([...remaining]); // Output: ['d', 'e']

            

              
                Copy
              
            
          

            IteratorHelpers.reduce(iterable, reducerFn, initialValue)
AsyncIteratorHelpers.reduce(asyncIterable, reducerFn, initialValue)

            

              
                Copy
              
            
          

            function* numberSequence(n) {
  for (let i = 1; i <= n; i++) {
    yield i;
  }
}

const sum = IteratorHelpers.reduce(numberSequence(10), (accumulator, currentValue) => accumulator + currentValue, 0);

console.log(sum); // Output: 55

            

              
                Copy
              
            
          

            IteratorHelpers.toArray(iterable)
AsyncIteratorHelpers.toArray(asyncIterable)

            

              
                Copy
              
            
          

            function* simpleGenerator() {
  yield 1;
  yield 2;
  yield 3;
}

const resultArray = IteratorHelpers.toArray(simpleGenerator());

console.log(resultArray); // Output: [1, 2, 3]

            

              
                Copy
              
            
          

            IteratorHelpers.forEach(iterable, callbackFn)
AsyncIteratorHelpers.forEach(asyncIterable, callbackFn)

            

              
                Copy
              
            
          

            function* names() {
  yield 'Alice';
  yield 'Bob';
  yield 'Charlie';
}

IteratorHelpers.forEach(names(), name => {
  console.log(`Processing name: ${name}`);
});
// Output:
// Processing name: Alice
// Processing name: Bob
// Processing name: Charlie

            

              
                Copy
              
            
          

            IteratorHelpers.forAll(iterable, predicateFn)
AsyncIteratorHelpers.forAll(asyncIterable, predicateFn)

            

              
                Copy
              
            
          

            function* mixedNumbers() {
  yield 5;
  yield -2;
  yield 10;
}

const allPositive = IteratorHelpers.forAll(mixedNumbers(), n => n > 0);
console.log(allPositive); // Output: false

const positiveOnly = [1, 2, 3];
const allPositiveCheck = IteratorHelpers.forAll(positiveOnly, n => n > 0);
console.log(allPositiveCheck); // Output: true

            

              
                Copy
              
            
          

            IteratorHelpers.some(iterable, predicateFn)
AsyncIteratorHelpers.some(asyncIterable, predicateFn)

            

              
                Copy
              
            
          

            function* oddNumbers() {
  yield 1;
  yield 3;
  yield 5;
}

const hasEven = IteratorHelpers.some(oddNumbers(), n => n % 2 === 0);
console.log(hasEven); // Output: false

const someEven = [1, 2, 3, 4];
const hasEvenCheck = IteratorHelpers.some(someEven, n => n % 2 === 0);
console.log(hasEvenCheck); // Output: true

            

              
                Copy
              
            
          

            IteratorHelpers.find(iterable, predicateFn)
AsyncIteratorHelpers.find(asyncIterable, predicateFn)

            

              
                Copy
              
            
          

            function* mixedSequence() {
  yield 1;
  yield 3;
  yield 4;
  yield 6;
}

const firstEven = IteratorHelpers.find(mixedSequence(), n => n % 2 === 0);
console.log(firstEven); // Output: 4

            

              
                Copy
              
            
          

            
IteratorHelpers.concat(iterable1, iterable2, ...)
AsyncIteratorHelpers.concat(asyncIterable1, asyncIterable2, ...)

            

              
                Copy
              
            
          

            function* lettersA() {
  yield 'a';
  yield 'b';
}

function* lettersB() {
  yield 'c';
  yield 'd';
}

const combined = IteratorHelpers.concat(lettersA(), lettersB());
console.log([...combined]); // Output: ['a', 'b', 'c', 'd']

            

              
                Copy
              
            
          

            
IteratorHelpers.join(iterable, separator)
AsyncIteratorHelpers.join(asyncIterable, separator)

            

              
                Copy
              
            
          

            function* cities() {
  yield 'Tokyo';
  yield 'London';
  yield 'New York';
}

const cityString = IteratorHelpers.join(cities(), ", ");
console.log(cityString); // Output: "Tokyo, London, New York"

            

              
                Copy
              
            
          

            async function* fetchUserData(userIds) {
  for (const userId of userIds) {
    // Simulate fetching user data from a regional API
    // In a real-world scenario, this would be a fetch() call
    await new Promise(resolve => setTimeout(resolve, 100)); // Simulate network latency
    yield { id: userId, name: `User ${userId}`, region: 'EU' }; // Placeholder data
  }
}

async function* fetchUserDataFromOtherRegions(userIds) {
  for (const userId of userIds) {
    await new Promise(resolve => setTimeout(resolve, 150));
    yield { id: userId, name: `User ${userId}`, region: 'Asia' };
  }
}

async function processGlobalUsers() {
  const europeanUsers = fetchUserData([1, 2, 3]);
  const asianUsers = fetchUserDataFromOtherRegions([4, 5, 6]);

  // Combine and filter users older than a certain age (simulated)
  const combinedUsers = AsyncIteratorHelpers.concat(europeanUsers, asianUsers);
  
  // Simulate adding an 'age' property for filtering
  const usersWithAge = AsyncIteratorHelpers.map(combinedUsers, user => ({ ...user, age: Math.floor(Math.random() * 50) + 18 }));

  const filteredUsers = AsyncIteratorHelpers.filter(usersWithAge, user => user.age > 30);

  const userNames = await AsyncIteratorHelpers.map(filteredUsers, user => user.name);
  
  console.log("Users older than 30:");
  for await (const name of userNames) {
    console.log(name);
  }
}

processGlobalUsers();

            

              
                Copy
              
            
          

            function* rawSensorData() {
  yield { timestamp: 1678886400, value: 25.5, sensorId: 'A' };
  yield { timestamp: 1678886460, value: 26.1, sensorId: 'B' };
  yield { timestamp: 1678886520, value: 24.9, sensorId: 'A' };
  yield { timestamp: 1678886580, value: 27.0, sensorId: 'C' };
  yield { timestamp: 1678886640, value: 25.8, sensorId: 'B' };
}

// Process: Filter data from sensor 'A', convert Celsius to Fahrenheit, and take the first 2 readings.

const processedData = IteratorHelpers.take(
  IteratorHelpers.map(
    IteratorHelpers.filter(
      rawSensorData(),
      reading => reading.sensorId === 'A'
    ),
    reading => ({ ...reading, value: (reading.value * 9/5) + 32 })
  ),
  2
);

console.log("Processed data:");
console.log(IteratorHelpers.toArray(processedData));
/*
Output:
Processed data:
[
  { timestamp: 1678886400, value: 77.9, sensorId: 'A' },
  { timestamp: 1678886520, value: 76.82, sensorId: 'A' }
]
*/

            

              
                Copy
              
            
          

            import * as IteratorHelpers from '@js-temporal/polyfill'; // Example import path, actual path may vary
// or
import { map, filter, reduce } from '@js-temporal/polyfill'; // Destructuring imports

            

              
                Copy